Potential runtime crash: userInput.toLowerCase() is called before verifying userInput is a non-empty string. If formData is absent or input is missing (e.g., null), this will throw. Also, toLowerCase().trim() is duplicated; normalize once and reuse. Consider moving to a safe normalization and using a small lookup table for hardcoded answers to simplify and future-proof this logic.

const normalizedInput = (typeof userInput === 'string' ? userInput : '').toLowerCase().trim();
const HARD_CODED_ANSWERS: Record<string, string> = {
  'what is a planet computer?': 'A planet computer is a proprietary environment aware system that interoperates Climate forecasting, mapping and scheduling using cutting edge multi-agents to streamline automation and exploration on a planet',
  'what is qcx-terra?': 'QCX-Terra is a model garden of pixel level precision geospatial foundational models for efficient land feature predictions from satellite imagery',
};

if (HARD_CODED_ANSWERS[normalizedInput]) {
  const definition = HARD_CODED_ANSWERS[normalizedInput];

  const content = JSON.stringify({ input: userInput ?? '' });
  const type = 'input';

  aiState.update({
    ...aiState.get(),
    messages: [
      ...aiState.get().messages,
      { id: nanoid(), role: 'user', content, type },
    ],
  });

  const definitionStream = createStreamableValue();
  definitionStream.done(definition);

  uiStream.append(
    <Section title="response">
      <BotMessage content={definitionStream.value} />
    </Section>
  );

  const groupId = nanoid();
  const relatedQueries = { items: [] };

  aiState.done({
    ...aiState.get(),
    messages: [
      ...aiState.get().messages,
      { id: groupId, role: 'assistant', content: definition, type: 'response' },
      { id: groupId, role: 'assistant', content: JSON.stringify(relatedQueries), type: 'related' },
      { id: groupId, role: 'assistant', content: 'followup', type: 'followup' },
    ],
  });

  isGenerating.done(false);
  uiStream.done();

  return {
    id: groupId,
    isGenerating: isGenerating.value,
    component: uiStream.value,
    isCollapsed: isCollapsed.value,
  };
}

The id returned from this early-return block is a fresh nanoid() that does not match the groupeId used for the assistant messages. This likely breaks grouping/association between the UI component and the messages for that interaction.

return {
  id: groupeId, // or `groupId` if you rename it
  isGenerating: isGenerating.value,
  component: uiStream.value,
  isCollapsed: isCollapsed.value,
};

formData! is unsafe here and JSON.stringify(Object.fromEntries(formData)) can silently drop non-serializable values (e.g., File becomes {}). This can produce misleading content for the stored user message or even throw if formData is undefined. Consider constructing the content safely from known primitives (e.g., the input string).

const content = JSON.stringify({ input: userInput ?? '' });
const type = 'input';

All three assistant messages use the same id (groupeId). If id is used as a unique identifier (common in React lists/state), this will cause collisions and potentially break rendering or state updates. Use a unique id per message and, if grouping is needed, add a separate groupId property instead of reusing id.

aiState.done({
  ...aiState.get(),
  messages: [
    ...aiState.get().messages,
    {
      id: nanoid(),
      role: 'assistant',
      content: definition,
      type: 'response',
    },
    {
      id: nanoid(),
      role: 'assistant',
      content: JSON.stringify(relatedQueries),
      type: 'related',
    },
    {
      id: nanoid(),
      role: 'assistant',
      content: 'followup',
      type: 'followup',
    },
  ],
});

⚠️ Potential issue | 🔴 Critical

Null-safe normalization: prevent runtime on file-only or non-text submissions

userInput can be null/undefined (e.g., file-only requests). Calling .toLowerCase() will throw. Compute a normalized string once and guard against skip. Also avoid repeating .toLowerCase().trim().

Apply:

-  const userInput = skip
-    ? `{"action": "skip"}`
-    : (formData?.get('input') as string);
-
-  if (userInput.toLowerCase().trim() === 'what is a planet computer?' || userInput.toLowerCase().trim() === 'what is qcx-terra?') {
-    const definition = userInput.toLowerCase().trim() === 'what is a planet computer?'
+  const rawInput = skip ? null : formData?.get('input')
+  const userInput = typeof rawInput === 'string' ? rawInput : ''
+  const normalizedInput = userInput.toLowerCase().trim()
+
+  if (!skip && (normalizedInput === 'what is a planet computer?' || normalizedInput === 'what is qcx-terra?')) {
+    const definition = normalizedInput === 'what is a planet computer?'

In app/actions.tsx around lines 55 to 63, the code calls
userInput.toLowerCase().trim() which will throw when userInput is null/undefined
(e.g., file-only submissions); compute a single null-safe normalized string
(e.g., const normalized = (userInput ?? '').toString().toLowerCase().trim())
after handling skip, use that normalized variable in the conditional and
ternary, and ensure you short-circuit when skip is true so you don't attempt
normalization on undefined input.

⚠️ Potential issue | 🟠 Major

Do not persist entire FormData; store only the minimal input field

Serializing Object.fromEntries(formData!) risks leaking unrelated fields (and file metadata) into persisted chat messages and can yield {} for File values. Persist only { input } to align with getUIStateFromAIState expectations and minimize data retention.

-    const content = JSON.stringify(Object.fromEntries(formData!));
+    // Only persist minimal structured input to avoid leaking other form fields/files
+    const content = JSON.stringify({ input: userInput });
     const type = 'input';

Committable suggestion skipped: line range outside the PR's diff.

🧹 Nitpick | 🔵 Trivial

UI parity: append Follow-up section in the early path

General flow appends a Follow-up section to the stream; the early path should too for consistent UX.

-    uiStream.append(answerSection);
+    uiStream.append(answerSection);
+    uiStream.append(
+      <Section title="Follow-up">
+        <FollowupPanel />
+      </Section>
+    );

In app/actions.tsx around lines 89-90, the early return path appends the
answerSection to uiStream but omits appending the Follow-up section, causing UI
inconsistency; after the existing uiStream.append(answerSection) in the early
path, create or obtain the same followUpSection used in the normal flow and call
uiStream.append(followUpSection) there (ensure you reuse the same
structure/props to avoid duplication or mismatch and guard against
null/undefined before appending).

🧹 Nitpick | 🔵 Trivial

Avoid redeclaring groupeId

groupeId is already defined earlier (Line 50). Redeclaration here shadows it unnecessarily.

-    const groupeId = nanoid();
-    const relatedQueries = { items: [] };
+    const relatedQueries = { items: [] };

In app/actions.tsx around lines 91 to 93, the code redeclares "groupeId" which
was already defined at line 50, causing an unnecessary shadow; remove the "const
groupeId = nanoid();" declaration and either reuse the previously declared
variable (assign to it or just reference it) or, if a distinct new id is
required, rename this variable to a different, descriptive identifier (e.g.,
newGroupId) to avoid shadowing and keep naming consistent.